package com.example.mq.mqserver.datacenter;

import com.example.mq.MqApplication;
import com.example.mq.mqserver.core.Binding;
import com.example.mq.mqserver.core.Exchange;
import com.example.mq.mqserver.core.ExchangeType;
import com.example.mq.mqserver.core.MSGQueue;
import com.example.mq.mqserver.mapper.MetaMapper;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.util.List;

@Slf4j
public class DataBaseManager {

    // 数据库文件路径常量
    private static final String DB_FILE_PATH = "./data/meat.db";  // 数据库文件路径
    private static final String DATA_DIR_PATH = "./data";  // 数据目录路径

    // MetaMapper 对象，用于数据库操作
    private MetaMapper metaMapper;

    // 初始化数据库方法
    public void init() {
        metaMapper = MqApplication.context.getBean(MetaMapper.class);  // 获取 MetaMapper 实例

        // 如果数据库不存在
        if (!checkDBExists()) {
            createDataDirectory();  // 创建数据目录
            createTable();          // 创建数据库表
            createDefaultData();    // 插入默认数据
            log.info("[DataBaseManager] 数据库初始化完成!");  // 记录日志
        } else {
            log.info("[DataBaseManager] 数据库已经存在!");  // 如果数据库已存在，记录日志
        }
    }

    // 删除数据库方法
    public void deleteDB() {
        // 删除数据库文件，并记录删除结果
        boolean dbDeleted = deleteFile(DB_FILE_PATH);
        log.info("[DataBaseManager] 删除数据库文件{}!", dbDeleted ? "成功" : "失败");

        // 删除数据库目录，并记录删除结果
        boolean dirDeleted = deleteDirectory(DATA_DIR_PATH);
        log.info("[DataBaseManager] 删除数据库目录{}!", dirDeleted ? "成功" : "失败");
    }

    // 检查数据库是否存在
    private boolean checkDBExists() {
        return new File(DB_FILE_PATH).exists();  // 检查数据库文件是否存在
    }

    // 创建数据目录
    private void createDataDirectory() {
        File dataDir = new File(DATA_DIR_PATH);  // 创建 File 对象表示数据目录
        if (!dataDir.exists()) {  // 如果目录不存在
            dataDir.mkdirs();  // 创建目录
            log.info("[DataBaseManager] 数据目录创建成功!");  // 记录日志
        } else {
            log.info("[DataBaseManager] 数据目录已存在!");  // 如果目录已存在，记录日志
        }
    }

    // 创建数据库表
    private void createTable() {
        metaMapper.createExchangeTable();   // 创建 Exchange 表
        metaMapper.createQueueTable();      // 创建 Queue 表
        metaMapper.createBindingTable();    // 创建 Binding 表
        log.info("[DataBaseManager] 创建表完成!");
    }

    // 插入默认数据
    private void createDefaultData() {
        // 创建并设置默认的 Exchange 对象
        Exchange defaultExchange = new Exchange("");// 设置 Exchange 名称为空
        defaultExchange.setType(ExchangeType.DIRECT);   // 设置 Exchange 类型为 DIRECT
        defaultExchange.setDurable(true);               // 设置为持久化
        defaultExchange.setAutoDelete(false);           // 设置为不自动删除

        // 插入默认的 Exchange 对象
        metaMapper.insertExchange(defaultExchange);
        log.info("[DataBaseManager] 创建初始数据完成!");
    }

    // 删除指定文件
    private boolean deleteFile(String filePath) {
        File file = new File(filePath);  // 创建一个文件对象

        // 检查文件是否存在
        if (file.exists()) {
            return file.delete();  // 如果文件存在，删除文件并返回结果
        }

        return false;  // 如果文件不存在，返回 false
    }

    // 删除指定目录及其所有内容
    private boolean deleteDirectory(String dirPath) {
        File dir = new File(dirPath);  // 创建一个文件对象表示目录

        // 如果目录不存在
        if (!dir.exists()) {
            log.warn("删除目录不存在");
            return true;
        }

        // 检查路径是否是目录
        if (!dir.isDirectory()) {
            log.warn("删除路径不是目录");
            return true;
        }

        // 获取目录中的所有文件和子目录
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {  // 遍历所有文件和子目录
                if (file.isDirectory()) {  // 如果是子目录
                    deleteDirectory(file.getAbsolutePath());  // 递归删除子目录
                } else {
                    file.delete();  // 如果是文件，直接删除
                }
            }
        }

        return dir.delete();  // 删除目录本身，并返回删除结果
    }

    // 封装数据库操作的方法

    // 插入 Exchange 对象
    public void insertExchange(Exchange exchange) {
        metaMapper.insertExchange(exchange);
    }

    // 查询所有 Exchange 对象
    public List<Exchange> selectAllExchanges() {
        return metaMapper.selectAllExchanges();
    }

    // 删除指定的 Exchange 对象
    public void deleteExchange(String exchangeName) {
        metaMapper.deleteExchange(exchangeName);
    }

    // 插入 Queue 对象
    public void insertQueue(MSGQueue queue) {
        metaMapper.insertQueue(queue);
    }

    // 查询所有 Queue 对象
    public List<MSGQueue> selectAllQueues() {
        return metaMapper.selectAllQueues();
    }

    // 删除指定的 Queue 对象
    public void deleteQueue(String queueName) {
        metaMapper.deleteQueue(queueName);
    }

    // 插入 Binding 对象
    public void insertBinding(Binding binding) {
        metaMapper.insertBinding(binding);
    }

    // 查询所有 Binding 对象
    public List<Binding> selectAllBindings() {
        return metaMapper.selectAllBindings();
    }

    // 删除指定的 Binding 对象
    public void deleteBinding(Binding binding) {
        metaMapper.deleteBinding(binding);
    }
}
